home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Misc / SciCalc1.1 / Source / ValueStack.m < prev    next >
Text File  |  1994-04-24  |  7KB  |  229 lines
  1. /******************************************************************************
  2. *H* ValueStack.m {Maintain push down stack of double values } V0.0, 09-FEB-91 *
  3. *C* V0.0 09-FEB-91 Initial version                                      --MDM *
  4. ******************************************************************************/
  5.  
  6. /* Standard C Library includes */
  7. #import <stdio.h>           /* Standard I/O functions and definitions */
  8. #import <stdlib.h>          /* Standard C memory allocation prototypes */
  9.  
  10. #import "ValueStack.h"        /* ValueStack interface specification */
  11.  
  12.  
  13. @implementation ValueStack
  14.  
  15.  
  16. /* Private Object Wide Definitions */
  17. #define OCnullStack     (OTvalueStackItem *) 0
  18.  
  19.  
  20.  
  21. /******************************************************************************
  22. * METHOD:- init                                                            *
  23. *   Initialize a new instance of a ValueStack class.                          *
  24. ******************************************************************************/
  25. - init
  26.  
  27. {/* BEGIN:-init */
  28. self = [super init];
  29. OVstackTop = OCnullStack;
  30. return self;
  31. }/* END:-init */
  32.  
  33.  
  34.  
  35.  
  36. /******************************************************************************
  37. ***                   I N S T A N C E   M E T H O D S                         ***
  38. ******************************************************************************/
  39.  
  40. /******************************************************************************
  41. * METHOD:- free                                                           *
  42. *   All data currently on the  ValueStack  is  poped and freed, returning the *
  43. * allocated memory back to the system pool.                                   *
  44. ******************************************************************************/
  45. - free
  46.  
  47. {   /* Local Variables */
  48.     OTvalueStackItem *tmp_blink;
  49.  
  50. /* BEGIN free */
  51. while (OVstackTop != OCnullStack)
  52.     {/* Get pointer to lower stack item and free top item */
  53.     tmp_blink = OVstackTop->blink;
  54.     free( (char *) OVstackTop );
  55.     OVstackTop  = tmp_blink;
  56.     OVstackSize = 0;
  57.     }
  58.  
  59. /* Request super class to perform its free method */
  60. return [super free];
  61. }/* END free */
  62.  
  63.  
  64.  
  65. /******************************************************************************
  66. * METHOD:- ClearStack                                                            *
  67. *   Pop and free each element on the stack until the stack is empty.          *
  68. ******************************************************************************/
  69. - ClearStack
  70.  
  71. {   /* Local Variables */
  72.     OTvalueStackItem  *tmp_blink;
  73.  
  74. /* BEGIN ClearStack */
  75. while ( OVstackTop )
  76.     {/* Stack is not empty, free top item */
  77.     tmp_blink  = OVstackTop->blink;
  78.     free ( (char *) OVstackTop );
  79.     OVstackTop = tmp_blink;
  80.     }
  81.  
  82. OVstackSize = 0;
  83. return self;
  84. }/* END ClearStack */
  85.  
  86.  
  87.  
  88. /******************************************************************************
  89. * METHOD:- GetSize                                                            *
  90. *   Return the current number of items in the Value Stack.                    *
  91. ******************************************************************************/
  92. - (unsigned long) GetSize
  93.  
  94. {/* BEGIN GetSize */
  95. return OVstackSize;
  96. }/* END GetSize */
  97.  
  98.  
  99.  
  100. /******************************************************************************
  101. * METHOD:- Peek                                                               *
  102. *   Return the value on the top  of  the  stack  without removing it from the *
  103. * stack.                                                                      *
  104. ******************************************************************************/
  105. - Peek: (double *) value
  106.  
  107. {/* BEGIN Peek */
  108. if ( OVstackTop )
  109.     {/* The stack is not empty return top stack value */
  110.     *value = OVstackTop->value;
  111.     return self;
  112.     }
  113. else
  114.     {/* Report illegal reference to standard error */
  115. #ifdef DEBUG
  116.     fprintf(stderr, "ValueStack: Peek on empty stack returning 0.0\n");
  117. #endif
  118.     *value = 0.0;
  119.     return nil;
  120.     }
  121. }/* END Peek */
  122.  
  123.  
  124.  
  125. /******************************************************************************
  126. * METHOD:- Pop                                                               *
  127. *   Return the value on the top of the stack and free top stack item.          *
  128. ******************************************************************************/
  129. - Pop: (double *) value
  130.  
  131. {   /* Local Variables */
  132.     OTvalueStackItem  *tmp_blink;
  133.  
  134. /* BEGIN Pop */
  135. if ( OVstackTop )
  136.     {/* Stack is not empty, free top item and return top value */
  137.     *value = OVstackTop->value;
  138.     tmp_blink = OVstackTop->blink;
  139.     free ( (char *) OVstackTop );
  140.     OVstackTop = tmp_blink;
  141.     OVstackSize--;
  142.     return self;        /* successful status */
  143.     }
  144.  
  145. else
  146.     {/* Stack is empty report error, return 0.0 */
  147. #ifdef DEBUG
  148.     fprintf(stderr, "ValueStack: Pop on empty stack returning 0.0\n");
  149. #endif
  150.     *value = 0.0;
  151.     return nil;            /* failure status */
  152.     }
  153. }/* END Pop */
  154.  
  155.  
  156.  
  157. /******************************************************************************
  158. * METHOD:- Push                                                               *
  159. *   Push a double float value  on  the  stack.   We allocate a new stack item *
  160. * setting its value field to  the supplied value and its blink field to point *
  161. * to the current stack top.  If a new stack item cannot be allocated an error *
  162. * message is written to stderr.                                                  *
  163. ******************************************************************************/
  164. - Push: (double) value
  165.  
  166. {   /* Local Variables */
  167.     OTvalueStackItem  *new_item;
  168.  
  169. /* BEGIN Push */
  170. /* Allocate a new stack item */
  171. new_item = (OTvalueStackItem *) malloc(sizeof(OTvalueStackItem));
  172.  
  173. if ( new_item )
  174.     {/* New stack item allocated, initialize and link in new stack top */
  175.     new_item->value = value;
  176.     new_item->blink = OVstackTop;
  177.     OVstackTop = new_item;
  178.     OVstackSize++;
  179.     return self;    
  180.     }
  181.  
  182. else
  183.     {/* Allocation failed, report error to stderr */
  184. #ifdef DEBUG
  185.     fprintf(stderr, "ValueStack: Push allocation failure\n");
  186. #endif
  187.     return nil;
  188.     }
  189. }/* END Push */
  190.  
  191.  
  192.  
  193. /******************************************************************************
  194. * METHOD:- PrintStack                                                       *
  195. *   Print out the contents of the stack to standard output.                   *
  196. ******************************************************************************/
  197. - PrintStack
  198.  
  199. {   /* Local Variables */
  200.     OTvalueStackItem  *trace_link;
  201.     long               level;
  202.  
  203. /* BEGIN PrintStack */
  204. if ( OVstackTop )
  205.     {/* The stack is not empty so dump its contents */
  206.     trace_link = OVstackTop;
  207.     level      = 0;
  208.  
  209.     while ( trace_link )
  210.         {/* Not at bottom, print this item */
  211. #ifdef DEBUG
  212.         printf("%2f : (%ld)\n", trace_link->value, level--);
  213. #endif
  214.         trace_link = trace_link->blink;
  215.         }
  216.     }
  217.  
  218. else
  219.     {/* Stack is empty so print a message */
  220. #ifdef DEBUG
  221.     printf("ValueStack: stack empty\n");
  222. #endif
  223.     }
  224.  
  225. return self;
  226. }/* END PrintStack */
  227.  
  228. @end /* ValueStack Implementation */
  229.